home *** CD-ROM | disk | FTP | other *** search
/ The 640 MEG Shareware Studio 2 / The 640 Meg Shareware Studio CD-ROM Volume II (Data Express)(1993).ISO / clang / jcool01.zip / TEST_BIG.C < prev    next >
C/C++ Source or Header  |  1992-08-12  |  25KB  |  656 lines
  1. //
  2. // Copyright (C) 1991 Texas Instruments Incorporated.
  3. //
  4. // Permission is granted to any individual or institution to use, copy, modify,
  5. // and distribute this software, provided that this complete copyright and
  6. // permission notice is maintained, intact, in all copies and supporting
  7. // documentation.
  8. //
  9. // Texas Instruments Incorporated provides this software "as is" without
  10. // express or implied warranty.
  11. //
  12. // Updated: JAM 08/12/92 -- anach. form() replaced with iomanips
  13.  
  14. #include <iomanip.h>    // for hex
  15. #include <cool/Bignum.h>
  16. #include <test.h>
  17.  
  18. void run_constructor_tests() {
  19.   cout << "\nCoolBignum constructor tests:\n";
  20.  
  21.   cout << "long constructor:\n";
  22.   {CoolBignum b2(long(0));
  23.   TEST ("CoolBignum b2(long(0));", (long)b2 == (long)0, TRUE);}
  24.  
  25.   {CoolBignum b3(long(1));
  26.   TEST ("CoolBignum b3(long(1));", (long)b3 == (long)1, TRUE);}
  27.  
  28.   {CoolBignum b4(long(-1));
  29.   TEST ("CoolBignum b4(long(-1));", (long)b4 == (long)-1, TRUE);}
  30.  
  31.   {CoolBignum b5(long(MAXSHORT));
  32.   TEST ("CoolBignum b5(long(MAXSHORT));", (long)b5 == (long)MAXSHORT, TRUE);}
  33.   
  34.   {CoolBignum b6(long(-MAXSHORT));
  35.   TEST ("CoolBignum b6(long(-MAXSHORT));", (long)b6 == (long)-MAXSHORT, TRUE);}
  36.  
  37.   {CoolBignum b7(long(MAXINT));
  38.   TEST ("CoolBignum b7(long(MAXINT));", (long)b7 == (long)MAXINT, TRUE);}
  39.  
  40.   {CoolBignum b8(long(-MAXINT));
  41.   TEST ("CoolBignum b8(long(-MAXINT));", (long)b8 == (long)-MAXINT, TRUE);}
  42.  
  43.   {CoolBignum b9(long(MAXLONG));
  44.   TEST ("CoolBignum b9(long(MAXLONG));", (long)b9 == (long)MAXLONG, TRUE);}
  45.  
  46.   {CoolBignum b10(long(-MAXLONG));
  47.   TEST ("CoolBignum b10(long(-MAXLONG));", (long)b10 == (long)-MAXLONG, TRUE);}
  48.  
  49.   {CoolBignum b10l(long(0xF00000l));
  50.   TEST ("CoolBignum b10l(long(0xF00000l));", (long)b10l == 0xF00000, TRUE);}
  51.  
  52.   cout << "double constructor:\n";
  53.   {CoolBignum b11(0.0);
  54.   TEST ("CoolBignum b11(0.0);", (double)b11 == 0.0, TRUE);}
  55.  
  56.   {CoolBignum b12(1.0);
  57.   TEST ("CoolBignum b12(1.0);", (double)b12 == 1.0, TRUE);}
  58.  
  59.   {CoolBignum b13(-1.0);
  60.   TEST ("CoolBignum b13(-1.0);", (double)b13 == -1.0, TRUE);}
  61.  
  62.   {CoolBignum b14(MAXDOUBLE);
  63.   TEST ("CoolBignum b14(MAXDOUBLE);", (double)b14 == MAXDOUBLE, TRUE);}
  64.  
  65.   {CoolBignum b15(-MAXDOUBLE);
  66.   TEST ("CoolBignum b15(-MAXDOUBLE);", (double)b15 == -MAXDOUBLE, TRUE);}
  67.  
  68.   {CoolBignum b16(1234567.0);
  69.   TEST ("CoolBignum b16(1234567.0);", (double)b16 == 1234567.0, TRUE);}
  70.  
  71.   {CoolBignum b17(-1234567.0);
  72.   TEST ("CoolBignum b17(-1234567.0);", (double)b17 == -1234567.0, TRUE);}
  73.  
  74.   {CoolBignum b18(1234567000.0);
  75.   TEST ("CoolBignum b18(1234567000.0);", (double)b18 == 1234567000.0, TRUE);}
  76.  
  77.   {CoolBignum b19(-1234567000.0);
  78.   TEST ("CoolBignum b19(-1234567000.0);", (double)b19 == -1234567000.0, TRUE);}
  79.  
  80.   {CoolBignum b20(double(0xF00000)); TEST ("CoolBignum b20(double(0xF00000));",
  81.                       (double)b20 == (double)0xF00000, TRUE);}
  82.  
  83.   cout << "char* constructor:\n";
  84.   {CoolBignum b21("-1");
  85.   TEST ("CoolBignum b21(\"-1\");", (long)b21 == -1, TRUE);}
  86.  
  87.   {CoolBignum b22("+1");
  88.   TEST ("CoolBignum b22(\"+1\");", (long)b22 == 1, TRUE);}
  89.  
  90.   {CoolBignum b23("1");
  91.   TEST ("CoolBignum b23(\"1\");", (long)b23 == 1, TRUE);}
  92.  
  93.   {CoolBignum b24("123");
  94.   TEST ("CoolBignum b24(\"123\");", (long)b24 == 123, TRUE);}
  95.  
  96.   {CoolBignum b25("123e12");
  97.   TEST ("CoolBignum b25(\"123e12\");", (double)b25 == 123e12, TRUE);}
  98.  
  99.   {CoolBignum b26("123e120");
  100.   TEST ("CoolBignum b26(\"123e120\");", (double)b26 == 123e120, TRUE);}
  101.  
  102.   {CoolBignum b27("0x0");
  103.   TEST ("CoolBignum b27(\"0x0\");", (long)b27 == 0x0, TRUE);}
  104.  
  105.   {CoolBignum b28("0x9");
  106.   TEST ("CoolBignum b28(\"0x9\");", (long)b28 == 0x9, TRUE);}
  107.  
  108.   {CoolBignum b29("0xa");
  109.   TEST ("CoolBignum b29(\"0xa\");", (long)b29 == 0xa, TRUE);}
  110.  
  111.   {CoolBignum b30("0xf");
  112.   TEST ("CoolBignum b30(\"0xf\");", (long)b30 == 0xf, TRUE);}
  113.  
  114.   {CoolBignum b31("0xA");
  115.   TEST ("CoolBignum b31(\"0xA\");", (long)b31 == 0xA, TRUE);}
  116.  
  117.   {CoolBignum b32("0xF");
  118.   TEST ("CoolBignum b32(\"0xF\");", (long)b32 == 0xF, TRUE);}
  119.  
  120.   {CoolBignum b33("0x1aF");
  121.   TEST ("CoolBignum b33(\"0x1aF\");", (long)b33 == 0x1aF, TRUE);}
  122.  
  123.   {CoolBignum b34("0");
  124.   TEST ("CoolBignum b34(\"0\");", (long)b34 == 0, TRUE);}
  125.  
  126.   {CoolBignum b35("00");
  127.   TEST ("CoolBignum b35(\"00\");", (long)b35 == 0, TRUE);}
  128.  
  129.   {CoolBignum b36("012334567");
  130.   TEST ("CoolBignum b36(\"012334567\");", (long)b36 == 012334567, TRUE);}
  131.  
  132.   {CoolBignum b37("9");
  133.   TEST ("CoolBignum b37(\"9\");", (long)b37 == 9, TRUE);}
  134.  
  135. //  CoolBignum b38("09");
  136. //  TEST ("CoolBignum b38(\"09\");", (long)b38 == 9, TRUE);
  137.  
  138. //  CoolBignum b39(" 9");
  139. //  TEST ("CoolBignum b39(\" 9\");", (long)b39 == 9, TRUE);
  140.  
  141.   {CoolBignum b40("0XF");
  142.   TEST ("CoolBignum b40(\"0XF\");", (long)b40 == 0XF, TRUE);}
  143.  
  144.   cout << "CoolBignum& constructor:\n";
  145.   {CoolBignum b50(CoolBignum(0l));
  146.   TEST ("CoolBignum b50(CoolBignum(0l));", (long)b50 == 0l, TRUE);}
  147.  
  148.   {CoolBignum b51(CoolBignum(100l));
  149.   TEST ("CoolBignum b51(CoolBignum(100l));", (long)b51 == 100l, TRUE);}
  150. }
  151.  
  152. void run_conversion_operator_tests() {
  153.   cout << "\nConversion operator tests:\n";
  154.  
  155.   cout << "short conversion operator:\n";
  156.   TEST("short(CoolBignum(0l)) == 0", short(CoolBignum(0l)) == 0, TRUE);
  157.   TEST("short(CoolBignum(long(MAXSHORT))) == MAXSHORT",
  158.        short(CoolBignum(long(MAXSHORT))) == MAXSHORT, TRUE);
  159.   TEST("short(CoolBignum(long(-MAXSHORT))) == -MAXSHORT",
  160.        short(CoolBignum(long(-MAXSHORT))) == -MAXSHORT, TRUE);
  161.  
  162.   TEST("short(CoolBignum(long(-MAXSHORT+1))) == short(-MAXSHORT+1)",
  163.        short(CoolBignum(long(-MAXSHORT+1))) == short(-MAXSHORT+1), TRUE);
  164.  
  165. //  TEST("short(CoolBignum(long(MAXSHORT+1))) == short(MAXSHORT+1)",
  166. //       short(CoolBignum(long(MAXSHORT + 1))) == short(MAXSHORT + 1), TRUE);
  167.  
  168.   cout << "int conversion operator:\n";
  169.   TEST("int(CoolBignum(0l)) == 0", int(CoolBignum(0l)) == 0, TRUE);
  170.   TEST("int(CoolBignum(long(MAXINT))) == MAXINT",
  171.       int(CoolBignum(long(MAXINT))) == MAXINT, TRUE);
  172.   TEST("int(CoolBignum(long(-MAXINT))) == -MAXINT",
  173.        int(CoolBignum(long(-MAXINT))) == -MAXINT, TRUE);
  174.  
  175.   {CoolBignum b(long(MAXINT));
  176.   b++;
  177. //  TEST("CoolBignum b(long(MAXINT); b++; (int)b == int(MAXINT+1)",
  178. //       (int)b == int(MAXINT+1), TRUE);
  179.  
  180.   b = -b;
  181. //  TEST("CoolBignum b(long(MAXINT); b++; b=-b; (int)b == int(-(MAXINT+1))",
  182. //       (int)b == int(-(MAXINT+1)), TRUE);
  183.  
  184.   cout << "long conversion operator:\n";
  185.   TEST("long(CoolBignum(0l)) == 0", long(CoolBignum(0l)) == 0, TRUE);
  186.   TEST("long(CoolBignum(MAXLONG)) == MAXLONG",
  187.        long(CoolBignum(MAXLONG)) == MAXLONG, TRUE);
  188.   TEST("long(CoolBignum(-MAXLONG)) == -MAXLONG",
  189.        long(CoolBignum(-MAXLONG)) == -MAXLONG, TRUE);
  190.  
  191.   b = long(MAXLONG);
  192.   b++;
  193. //  TEST("CoolBignum b; b =(long(MAXLONG); b++; (long)b == long(MAXLONG+1)",
  194. //       (long)b == long(MAXLONG+1), TRUE);
  195.  
  196.   b = -b;
  197. //  TEST("CoolBignum b = (long(MAXLONG); b++; b=-b; (long)b == long(-(MAXLONG+1))",
  198. //       (long)b == long(-(MAXLONG+1)), TRUE);
  199.  
  200.   cout << "float conversion operator:\n";
  201.   float f;
  202.   TEST("float(CoolBignum(0.0)) == 0.0", ((float) CoolBignum(0.0)) == 0.0, TRUE);
  203.   TEST("float(CoolBignum(99999.0)) == 99999.0",
  204.        ((float) CoolBignum(99999.0)) == 99999.0, TRUE);
  205.   TEST("float(CoolBignum(MAXFLOAT)) == MAXFLOAT",
  206.        ((f = MAXFLOAT) == (float) CoolBignum(MAXFLOAT)), TRUE);
  207.   TEST("float(CoolBignum(-MAXFLOAT)) == -MAXFLOAT",
  208.        ((f = -MAXFLOAT) == float(CoolBignum(-MAXFLOAT))), TRUE);
  209.   b = MAXDOUBLE;
  210.   b++;
  211. //  f = (float) b;
  212. //  TEST("CoolBignum b = MAXDOUBLE; b++; (float)b == float(MAXDOUBLE+1)",
  213. //       f == float(MAXDOUBLE+1), TRUE);
  214.  
  215. //  f = (float) (-b);
  216. //  TEST("CoolBignum b = MAXDOUBLE; b++, b=-b; (float)b == float(-(MAXDOUBLE+1))",
  217. //       f = float(-(MAXDOUBLE+1)), TRUE);
  218.  
  219.  
  220.   cout << "double conversion operator:\n";
  221.   double d;
  222.   TEST("double(CoolBignum(0.0)) == 0.0", ((double) CoolBignum(0.0)) == 0.0, TRUE);
  223.   TEST("double(CoolBignum(99999.0)) == 99999.0",
  224.        (double) CoolBignum(99999.0) == 99999.0, TRUE);
  225.   TEST("double(CoolBignum(1e300)) == 1e300",
  226.        double(CoolBignum(1e300)) == 1e300, TRUE);
  227.   TEST("double(CoolBignum(-1e300)) == -1e300",
  228.        double(CoolBignum(-1e300)) == -1e300, TRUE);
  229.   TEST("double(CoolBignum(MAXFLOAT)) == MAXFLOAT",
  230.        ((d = MAXFLOAT) == (double) CoolBignum(MAXFLOAT)), TRUE);
  231.   TEST("double(CoolBignum(-MAXFLOAT)) == -MAXFLOAT",
  232.        ((d = -MAXFLOAT) == double(CoolBignum(-MAXFLOAT))), TRUE);
  233.   TEST("double(CoolBignum(MAXDOUBLE)) == MAXDOUBLE",
  234.        (double) CoolBignum(MAXDOUBLE) == MAXDOUBLE, TRUE);
  235.   TEST("double(CoolBignum(-MAXDOUBLE)) == -MAXDOUBLE",
  236.        (double) CoolBignum(-MAXDOUBLE) == -MAXDOUBLE, TRUE);
  237. //  d = (double) b;
  238. //  TEST("CoolBignum b = MAXDOUBLE; b++; (double)b == double(MAXDOUBLE+1)",
  239. //       d == float(MAXDOUBLE+1), TRUE);
  240.  
  241. //  d = (double) (-b);
  242. //  TEST("CoolBignum b =MAXDOUBLE; b++, b=-b; (double)b == double(-(MAXDOUBLE+1))",
  243. //       d = float(-(MAXDOUBLE+1)), TRUE);
  244. }}
  245.  
  246. void run_assignment_tests() {
  247.   cout << "\nStarting assignment tests:\n";
  248.   CoolBignum b1;
  249.  
  250.   TEST_RUN ("CoolBignum b1; b1 = 0xffff;", b1 = 0xffffl,
  251.         long(b1) == 0xffffl, TRUE);
  252.  
  253.   // double assignment operator
  254.   TEST_RUN ("double(b1) == -1.23e6", b1 = -1.23e6,
  255.         double(b1) == -1.23e6, TRUE);
  256.  
  257.   // long assignment operator
  258.   TEST_RUN ("long(b1) = -MAXINT", b1 = long(-MAXINT),
  259.         long(b1) == -MAXINT, TRUE);
  260.  
  261.   // char * assignment operator
  262.   TEST_RUN ("long(b1) = 0x1FFFFFl", b1 = "0x1FFFFF",
  263.         long(b1) == 0x1fffffl, TRUE);
  264.  
  265.  
  266.   // CoolBignum& assignment operator
  267.   b1 = "0x1FFFFF";
  268.   CoolBignum b5(0x1FFFFl);
  269.   TEST_RUN ("b1 = b5", b1 = b5, b1 == b5, TRUE);
  270. }
  271.  
  272. void run_logical_comparison_tests() {
  273.   cout << "\nStarting logical comparison tests:\n";
  274.   CoolBignum b0(long(0));
  275.   CoolBignum b1(long(1));
  276.   CoolBignum b2(long(MAXSHORT));
  277.   CoolBignum b3(long(-MAXSHORT));
  278.  
  279.   TEST("b0 == b0", b0 == b0, TRUE);
  280.   TEST("b0 == b1", b0 == b1, FALSE);
  281.   TEST("b0 == b2", b0 == b2, FALSE);
  282.   TEST("b0 == b3", b0 == b3, FALSE);
  283.   TEST("b1 == b2", b1 == b2, FALSE);
  284.   TEST("b1 == b3", b1 == b3, FALSE);
  285.   TEST("b2 == b3", b2 == b3, FALSE);
  286.  
  287.   TEST("b0 != b0", b0 != b0, FALSE);
  288.   TEST("b0 != b1", b0 != b1, TRUE);
  289.   TEST("b0 != b2", b0 != b2, TRUE);
  290.   TEST("b0 != b3", b0 != b3, TRUE);
  291.   TEST("b1 != b2", b1 != b2, TRUE);
  292.   TEST("b1 != b3", b1 != b3, TRUE);
  293.   TEST("b2 != b3", b2 != b3, TRUE);
  294.  
  295.   TEST("b0 < b0", b0 < b0, FALSE);
  296.   TEST("b0 < b1", b0 < b1, TRUE);
  297.   TEST("b0 < b2", b0 < b2, TRUE);
  298.   TEST("b0 < b3", b0 < b3, FALSE);
  299.   TEST("b1 < b2", b1 < b2, TRUE);
  300.   TEST("b1 < b3", b1 < b3, FALSE);
  301.   TEST("b2 < b3", b2 < b3, FALSE);
  302.  
  303.   TEST("b0 > b0", b0 > b0, FALSE);
  304.   TEST("b0 > b1", b0 > b1, FALSE);
  305.   TEST("b0 > b2", b0 > b2, FALSE);
  306.   TEST("b0 > b3", b0 > b3, TRUE);
  307.   TEST("b1 > b2", b1 > b2, FALSE);
  308.   TEST("b1 > b3", b1 > b3, TRUE);
  309.   TEST("b2 > b3", b2 > b3, TRUE);
  310.  
  311.   TEST ("b3 != b2", b3 != b2, TRUE);
  312.   TEST ("b3 != b3", b3 != b3, FALSE);
  313.   TEST ("b3 < b2", b3 < b2, TRUE);
  314.   TEST ("b3 <= b2", b3 <= b2, TRUE);
  315.   TEST ("b3 <= b3", b3 <= b3, TRUE);
  316.   TEST ("b3 > b3", b3 > b3, FALSE);
  317.   TEST ("b3 > b2", b3 > b2, FALSE);
  318.   TEST ("b3 >= b2", b3 >= b2, FALSE);
  319.   TEST ("b3 >= b3", b3 >= b3, TRUE);
  320.   TEST ("b2 >= b2", b2 >= b2, TRUE);
  321. }
  322.  
  323. void run_division_tests() {
  324.   cout << "\nStarting division tests:\n";
  325.  
  326.   TEST("long(CoolBignum(0l)/CoolBignum(1l))", long(CoolBignum(0l)/CoolBignum(1l)), 0);
  327.   TEST("long(CoolBignum(-1l)/CoolBignum(1l))", long(CoolBignum(-1l)/CoolBignum(1l)), -1);
  328.  
  329.   CoolBignum b1,b2,b3;
  330.   long i,j,k,l;
  331.   long div_errors = 0;
  332.   long mod_errors = 0;
  333.  
  334.   cout << " for (i = 0xFFFFFF; i > 0; i /= 0x10) \n";
  335.   cout << "   for (j = 0x7FFFFFF; j > 0; j /= 0x10) \n";
  336.   cout << "     for (k = 1; k < 17; k++) \n";
  337.   cout << "       for (l = 1; l < 17; l++) \n         ";
  338.   {for (i = 0xFFFFFF; i > 0; i /= 0x10) {
  339.     cout.put('.');
  340.     cout.flush();
  341.     for (j = 0x7FFFFFF; j > 0; j /= 0x10) {
  342.       for (k = 1; k < 17; k++) {
  343.     for (l = 1; l < 17; l++) {
  344.       b1 = CoolBignum(i+k);
  345.       b2 = CoolBignum(j+l);
  346.       b3 = CoolBignum(long((i+k)/(j+l)));
  347.       if (b1/b2 != b3) {
  348.         TEST("(CoolBignum(i+k)/CoolBignum(j+l)) == CoolBignum(long((i+k)/(j+l)))",
  349.          FALSE, TRUE);
  350.         cout << "i=" << hex << i << ", j=" << hex << j << ", k=" << hex << k << ", l=" << hex << l << "\n" << dec;
  351.         div_errors++;
  352.       }
  353.       b3 = CoolBignum(long((i+k)%(j+l)));
  354.       if (b1%b2 != b3) {
  355.         TEST("(CoolBignum(i+k)%CoolBignum(j+l)) == CoolBignum(long((i+k)%(j+l)))",
  356.          FALSE, TRUE);
  357.         cout << "i=" << hex << i << ", j=" << hex << j << ", k=" << hex << k << ", l=" << hex << l << "\n" << dec;
  358.         mod_errors++;
  359.       }
  360.     }
  361.       }
  362.     }
  363.   }}
  364.  
  365.   cout << "\n";
  366.   TEST("(CoolBignum(i+k)/CoolBignum(j+l)) == CoolBignum(long((i+k)/(j+l)))",
  367.        div_errors == 0, TRUE);
  368.   TEST("(CoolBignum(i+k)%CoolBignum(j+l)) == CoolBignum(long((i+k)%(j+l)))",
  369.        mod_errors == 0, TRUE);
  370.  
  371. /*
  372.   char num[130], den[130];
  373.   CoolBignum b,r;
  374.   
  375.   while (1) {
  376.     cout << "Enter next numerator:  ";
  377.     cin >> num;
  378.     cout << "Enter next denominator:  ";
  379.     cin >> den;
  380.  
  381.     b = CoolBignum(num)/CoolBignum(den);
  382.     r = CoolBignum(num) % CoolBignum(den);
  383.     cout << "\nquotient  = " << b << "\n";
  384.     cout <<   "            "; b.dump(); cout << "\n";
  385.     cout << "\nremainder = " << r << "\n";
  386.     cout <<   "            "; r.dump(); cout << "\n";
  387.  
  388.   }
  389. */
  390. }
  391.  
  392. void run_multiplication_division_tests() {    
  393.   cout << "\nCheck example in book:\n";
  394.  
  395.   CoolBignum b2 = "0xFFFFFFFF";            // Create CoolBignum object
  396.   CoolBignum b3 = "12345e30";            // Create CoolBignum object
  397.  
  398.   TEST ("(b2*b3) / b3 = b2", ((b2*b3) / b3 == b2), 1);
  399.   TEST ("(b2*b3) / b2 = b3", ((b2*b3) / b2 == b3), 1);
  400.   TEST ("((b3/b2) * b2) + (b3%b2) = b3", (((b3/b2) * b2) + (b3%b2) == b3), 1);
  401. }
  402.  
  403. void run_addition_subtraction_tests() {
  404.   cout << "\nStarting addition, subtraction tests:\n";
  405.  
  406.   long i,j;
  407.   long add_errors = 0;
  408.   long sub_errors = 0;
  409.   CoolBignum bi,bj,bij;
  410.  
  411.   cout << " for (i = 1; i < 0xFFFFFFF;  i *= 3) \n";
  412.   cout << "   for (j = 1; j < 0xFFFFFFF; j *= 3) \n      ";
  413.  
  414.   {for (i = 1; i < 0xFFFFFFF;  i *= 3) {
  415.     cout.put('.');
  416.     cout.flush();
  417.     for (j = 1; j < 0xFFFFFFF; j *= 3) {
  418.       bi = i;
  419.       bj = j;
  420.       bij = CoolBignum(i+j);
  421.       if (bi + bj != bij) {
  422.     TEST("bi + bj == CoolBignum(i + j)", FALSE, TRUE);
  423.    cout << "i = " << hex << i << ", j = " << hex << j << "\n" << dec;
  424.     add_errors++;
  425.       }
  426.       bij = CoolBignum(i-j);
  427.       if (bi - bj != bij) {
  428.         TEST("bi - bj == CoolBignum(i - j)", FALSE, TRUE);
  429.    cout << "i = " << hex << i << ", j = " << hex << j << "\n" << dec;
  430.     sub_errors++;
  431.       }
  432.     }
  433.   }}
  434.   cout << "\n";
  435.   TEST("bi + bj == CoolBignum(i + j)", add_errors==0, TRUE);
  436.   TEST("bi - bj == CoolBignum(i - j)", sub_errors==0, TRUE);
  437.  
  438.   CoolBignum b0(0l);
  439.   CoolBignum zillion("1000000000000000000");
  440.   CoolBignum b1000(1000l), b1000000(1000000l);
  441.  
  442.   TEST("-b0 == b0", (-b0 == b0), TRUE);
  443.   TEST("-b1000 == CoolBignum(-1l)*b1000", (-b1000 == CoolBignum(-1l)*b1000), TRUE);
  444.   TEST("-(-b1000000) == b1000000", (-(-b1000000) == b1000000), TRUE);
  445.   TEST("b0 + b1000 == b1000", (b0 + b1000 == b1000), TRUE);
  446.   TEST("b0 + b1000000 == b1000000", (b0 + b1000000 == b1000000), TRUE);
  447.   TEST("b1000 + b0 == b1000", (b1000 + b0 == b1000), TRUE);
  448.   TEST("b1000000 + b0 == b1000000", (b1000000 + b0 == b1000000), TRUE);
  449.   TEST("b0 + (-b1000) == -b1000", (b0 + (-b1000) == -b1000), TRUE);
  450.   TEST("-b1000 + b0 == -b1000", (-b1000 + b0 == -b1000), TRUE);
  451.   TEST("-b1000 + (-b1000) == (CoolBignum(2l)*(-b1000))",
  452.        (-b1000 + (-b1000) == (CoolBignum(2l)*(-b1000))), TRUE);
  453.   TEST("-b1000000 + (-b1000000) == (CoolBignum(2l)*(-b1000000))",
  454.        (-b1000000 + (-b1000000) == (CoolBignum(2l)*(-b1000000))), TRUE);
  455.   TEST("b1000000 + (-b1000000) == b0", (b1000000 + (-b1000000) == b0), TRUE);
  456.   TEST("zillion + (-zillion) == b0", (zillion + (-zillion) == b0), TRUE);
  457.   TEST("zillion + b1000 == b1000000*b1000000*b1000000 + b1000",
  458.        (zillion + b1000 == b1000000*b1000000*b1000000 + b1000), TRUE);
  459.  
  460.   TEST("-b0 == b0", (-b0 == b0), TRUE);
  461.   TEST("-b1000 == CoolBignum(-1l)*b1000", (-b1000 == CoolBignum(-1l)*b1000), TRUE);
  462.   TEST("-(-b1000000) == b1000000", (-(-b1000000) == b1000000), TRUE);
  463.  
  464.   TEST("b0 - b1000 == -b1000", (b0 - b1000 == -b1000), TRUE);
  465.   TEST("b0 - b1000000 == -b1000000", (b0 -b1000000 == -b1000000), TRUE);
  466.   TEST("b1000 - b0 == b1000", (b1000 - b0 == b1000), TRUE);
  467.   TEST("b1000000 - b0 == b1000000", (b1000000 - b0 == b1000000), TRUE);
  468.   TEST("b0 - (-b1000) == b1000", (b0 - (-b1000) == b1000), TRUE);
  469.   TEST("-b1000 - b0 == -b1000", (-b1000 - b0 == -b1000), TRUE);
  470.   TEST("-b1000 - (-b1000) == b0", (-b1000 - (-b1000) == b0), TRUE);
  471.   TEST("-b1000 - (-zillion) == zillion - b1000",
  472.        (-b1000 - (-zillion) == zillion - b1000), TRUE);
  473.   TEST("-b1000000 - (-b1000000) == b0", (-b1000000 - (-b1000000) == b0), TRUE);
  474.   TEST("-b1000000 - (b1000000) == -CoolBignum(2l)*b1000000",
  475.        (-b1000000 - (b1000000) == -CoolBignum(2l)*b1000000), TRUE);
  476.   TEST("b1000000 - (-b1000000) == CoolBignum(2l)*b1000000",
  477.        (b1000000 - (-b1000000) == CoolBignum(2l)*b1000000), TRUE);
  478.   TEST("zillion - (-zillion) == CoolBignum(2l)*zillion",
  479.        (zillion - (-zillion) == CoolBignum(2l)*zillion), TRUE);
  480.   TEST("zillion - b1000 == b1000000*b1000000*b1000000 - b1000",
  481.        (zillion - b1000 == b1000000*b1000000*b1000000 - b1000), TRUE);
  482.   TEST("-zillion - b1000 == -b1000000*b1000000*b1000000 - b1000",
  483.        (-zillion - b1000 == -b1000000*b1000000*b1000000 - b1000), TRUE);
  484.  
  485.   // example in book
  486.   CoolBignum b2 = "0xFFFFFFFF";            // Create CoolBignum object
  487.   CoolBignum b3 = "12345e30";            // Create CoolBignum object
  488.   TEST ("(b2+b3) - b2 = b3", (b2+b3) - b2 == b3, 1);
  489.   TEST ("(b2+b3) - b3 = b2", (b2+b3) - b3 == b2, 1);
  490. }
  491.  
  492. void run_multiplication_tests() {
  493.   cout << "\nStarting multiplication tests:\n";
  494.  
  495.   CoolBignum b0(0l), b1000(1000l), b1000000(1000000l),
  496.   zillion("1000000000000000000");
  497.  
  498.   
  499.   TEST("b0*b0 == b0", (b0*b0 == b0), TRUE);
  500.   TEST("b0*b1000 == b0", (b0*b1000 == b0), TRUE);
  501.   TEST("b1000*b0 == b0", (b1000*b0 == b0), TRUE);
  502.   TEST("b1000*b1000 == b1000000", (b1000*b1000 == b1000000), TRUE);
  503.   TEST("b1000*b1000000 == b1000000*b1000",
  504.        (b1000*b1000000 == b1000000*b1000), TRUE);
  505.   TEST("-b1000000*b1000000*b1000000 == -zillion",
  506.        (-b1000000*b1000000*b1000000 == -zillion), TRUE);
  507.   TEST("zillion*-b1000 == b1000*-zillion",
  508.        (zillion*-b1000 == b1000*-zillion), TRUE);
  509. }
  510.  
  511. void run_left_shift_tests() {
  512.  
  513.   CoolBignum b1(1l);
  514.  
  515.   // left shift
  516.   TEST("int(b1) == 1",int(b1) == 1,TRUE);
  517.   TEST("long(b1 << 1) == 2",long(b1 << 1) == 2,TRUE);
  518.   TEST("long(b1 << 2) == 4",long(b1 << 2) == 4,TRUE);
  519.   TEST("long(b1 << 3) == 8",long(b1 << 3) == 8,TRUE);
  520.   TEST("long(b1 << 4) == 16",long(b1 << 4) == 16,TRUE);
  521.   TEST("long(b1 << 5) == 32",long(b1 << 5) == 32,TRUE);
  522.   TEST("long(b1 << 6) == 64",long(b1 << 6) == 64,TRUE);
  523.   TEST("long(b1 << 7) == 128",long(b1 << 7) == 128,TRUE);
  524.   TEST("long(b1 << 8) == 256",long(b1 << 8) == 256,TRUE);
  525.   TEST("long(b1 << 9) == 512",long(b1 << 9) == 512,TRUE);
  526.   TEST("long(b1 << 10) == 1024",long(b1 << 10) == 1024,TRUE);
  527.   TEST("long(b1 << 11) == 2048",long(b1 << 11) == 2048,TRUE);
  528.   TEST("long(b1 << 12) == 4096",long(b1 << 12) == 4096,TRUE);
  529.   TEST("long(b1 << 13) == 8192",long(b1 << 13) == 8192,TRUE);
  530.   TEST("long(b1 << 14) == 16384",long(b1 << 14) == 16384,TRUE);
  531.   TEST("long(b1 << 15) == 32768",long(b1 << 15) == 32768,TRUE);
  532.   TEST("long(b1 << 16) == 65536",long(b1 << 16) == 65536,TRUE);
  533.   TEST("(b1 << 32) == CoolBignum(\"4294967296\")",
  534.        (b1 << 32) == CoolBignum("4294967296"),TRUE);
  535.   TEST("long(-b1 << 1) == -2",long(-b1 << 1) == -2,TRUE);
  536.   TEST("long(-b1 << 2) == -4",long(-b1 << 2) == -4,TRUE);
  537.   TEST("long(-b1 << 3) == -8",long(-b1 << 3) == -8,TRUE);
  538.   TEST("long(-b1 << 4) == -16",long(-b1 << 4) == -16,TRUE);
  539.   TEST("long(-b1 << 5) == -32",long(-b1 << 5) == -32,TRUE);
  540.   TEST("long(-b1 << 6) == -64",long(-b1 << 6) == -64,TRUE);
  541.   TEST("long(-b1 << 7) == -128",long(-b1 << 7) == -128,TRUE);
  542.   TEST("long(-b1 << 8) == -256",long(-b1 << 8) == -256,TRUE);
  543.   TEST("long(-b1 << 9) == -512",long(-b1 << 9) == -512,TRUE);
  544.   TEST("long(-b1 << 10) == -1024",long(-b1 << 10) == -1024,TRUE);
  545.   TEST("long(-b1 << 11) == -2048",long(-b1 << 11) == -2048,TRUE);
  546.   TEST("long(-b1 << 12) == -4096",long(-b1 << 12) == -4096,TRUE);
  547.   TEST("long(-b1 << 13) == -8192",long(-b1 << 13) == -8192,TRUE);
  548.   TEST("long(-b1 << 14) == -16384",long(-b1 << 14) == -16384,TRUE);
  549.   TEST("long(-b1 << 15) == -32768",long(-b1 << 15) == -32768,TRUE);
  550.   TEST("long(-b1 << 16) == -65536",long(-b1 << 16) == -65536,TRUE);
  551.   TEST("(-b1 << 32) == CoolBignum(\"-4294967296\")",
  552.        (-b1 << 32) == CoolBignum("-4294967296"),TRUE);
  553.   TEST("long(b1 << -16) == 0",long(b1 << -16) == 0,TRUE);
  554.   TEST("long(-b1 << -16) == 0",long(-b1 << -16) == 0,TRUE);
  555. }
  556.  
  557. void run_right_shift_tests() {
  558.   // right shift
  559.   CoolBignum b2("4294967296");
  560.   TEST("b2 == CoolBignum(\"4294967296\")",b2 == CoolBignum("4294967296"), TRUE);
  561.   TEST("(b2 >> 1) == CoolBignum(\"2147483648\")",
  562.        (b2 >> 1) == CoolBignum("2147483648"),TRUE);
  563.   TEST("long(b2 >> 2) == 1073741824",long(b2 >> 2) == 1073741824l,TRUE);
  564.   TEST("long(b2 >> 3) == 536870912",long(b2 >> 3) == 536870912l,TRUE);
  565.   TEST("long(b2 >> 4) == 268435456",long(b2 >> 4) == 268435456l,TRUE);
  566.   TEST("long(b2 >> 5) == 134217728",long(b2 >> 5) == 134217728l,TRUE);
  567.   TEST("long(b2 >> 6) == 67108864",long(b2 >> 6) == 67108864l,TRUE);
  568.   TEST("long(b2 >> 7) == 33554432",long(b2 >> 7) == 33554432l,TRUE);
  569.   TEST("long(b2 >> 8) == 16777216",long(b2 >> 8) == 16777216l,TRUE);
  570.   TEST("long(b2 >> 9) == 8388608",long(b2 >> 9) == 8388608l,TRUE);
  571.   TEST("long(b2 >> 10) == 4194304",long(b2 >> 10) == 4194304l,TRUE);
  572.   TEST("long(b2 >> 11) == 2097152",long(b2 >> 11) == 2097152l,TRUE);
  573.   TEST("long(b2 >> 12) == 1048576",long(b2 >> 12) == 1048576l,TRUE);
  574.   TEST("long(b2 >> 13) == 524288",long(b2 >> 13) == 524288l,TRUE);
  575.   TEST("long(b2 >> 14) == 262144",long(b2 >> 14) == 262144l,TRUE);
  576.   TEST("long(b2 >> 15) == 131072",long(b2 >> 15) == 131072l,TRUE);
  577.   TEST("long(b2 >> 16) == 65536",long(b2 >> 16) == 65536l,TRUE);
  578.   TEST("long(b2 >> 32) == 1",long(b2 >> 32) == 1l,TRUE);
  579.   TEST("long(b2 >> 33) == 0",long(b2 >> 33) == 0l,TRUE);
  580.   TEST("long(b2 >> 67) == 0",long(b2 >> 67) == 0l,TRUE);
  581.   TEST("(-b2 >> 1) == CoolBignum(\"-2147483648\")",
  582.        (-b2 >> 1) == CoolBignum("-2147483648"),TRUE);
  583.   TEST("long(-b2 >> 2) == -1073741824",long(-b2 >> 2) == -1073741824l,TRUE);
  584.   TEST("long(-b2 >> 3) == -536870912",long(-b2 >> 3) == -536870912l,TRUE);
  585.   TEST("long(-b2 >> 4) == -268435456",long(-b2 >> 4) == -268435456l,TRUE);
  586.   TEST("long(-b2 >> 5) == -134217728",long(-b2 >> 5) == -134217728l,TRUE);
  587.   TEST("long(-b2 >> 6) == -67108864",long(-b2 >> 6) == -67108864l,TRUE);
  588.   TEST("long(-b2 >> 7) == -33554432",long(-b2 >> 7) == -33554432l,TRUE);
  589.   TEST("long(-b2 >> 8) == -16777216",long(-b2 >> 8) == -16777216l,TRUE);
  590.   TEST("long(-b2 >> 9) == -8388608",long(-b2 >> 9) == -8388608l,TRUE);
  591.   TEST("long(-b2 >> 10) == -4194304",long(-b2 >> 10) == -4194304l,TRUE);
  592.   TEST("long(-b2 >> 11) == -2097152",long(-b2 >> 11) == -2097152l,TRUE);
  593.   TEST("long(-b2 >> 12) == -1048576",long(-b2 >> 12) == -1048576l,TRUE);
  594.   TEST("long(-b2 >> 13) == -524288",long(-b2 >> 13) == -524288l,TRUE);
  595.   TEST("long(-b2 >> 14) == -262144",long(-b2 >> 14) == -262144l,TRUE);
  596.   TEST("long(-b2 >> 15) == -131072",long(-b2 >> 15) == -131072l,TRUE);
  597.   TEST("long(-b2 >> 16) == -65536",long(-b2 >> 16) == -65536l,TRUE);
  598.   TEST("long(-b2 >> 32) == -1",long(-b2 >> 32) == -1,TRUE);
  599.   TEST("long(-b2 >> 33) == -0",long(-b2 >> 33) == 0,TRUE);
  600.   TEST("long(-b2 >> 67) == -0",long(-b2 >> 67) == 0,TRUE);
  601. }
  602. void run_shift_tests() {
  603.   cout << "\nStarting shift tests:\n";
  604.  
  605.   run_left_shift_tests();
  606.   run_right_shift_tests();
  607. /*
  608.   CoolBignum b;
  609.   char s[100];
  610.   int sh;
  611.  
  612.   while (1) {
  613.     cout << "Enter next CoolBignum:  ";
  614.     cin >> s;
  615.     b = s;
  616.     cout << "Enter shift amount: ";
  617.     cin >> sh;
  618.     cout << "Shift == " << sh << "\n";
  619.  
  620.     b = b << sh;
  621.   }
  622. */    
  623. }
  624.  
  625. void test_leak() {
  626.   for (;;) {
  627.     run_constructor_tests();
  628.     run_conversion_operator_tests();
  629.     run_assignment_tests();
  630.     run_addition_subtraction_tests();
  631.     run_multiplication_tests();
  632.     run_division_tests();
  633.     run_multiplication_division_tests();
  634.     run_shift_tests();
  635.     run_logical_comparison_tests();
  636.   }
  637. }
  638.  
  639. int main (void) {
  640.   START("CoolBignum");
  641.   run_constructor_tests();
  642.   run_conversion_operator_tests();
  643.   run_assignment_tests();
  644.   run_addition_subtraction_tests();
  645.   run_multiplication_tests();
  646.   run_division_tests();
  647.   run_multiplication_division_tests();
  648.   run_shift_tests();
  649.   run_logical_comparison_tests();
  650. #if LEAK
  651.   test_leak();
  652. #endif
  653.   SUMMARY();
  654.   return 0;
  655. }
  656.